/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package gmovil_jpa.controladores;

import gmovil_jpa.controladores.exceptions.IllegalOrphanException;
import gmovil_jpa.controladores.exceptions.NonexistentEntityException;
import gmovil_jpa.entidades.Usuario;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import gmovil_jpa.entidades.PerfilUsuario;
import gmovil_jpa.entidades.Comision;
import java.util.ArrayList;
import java.util.List;
import gmovil_jpa.entidades.Remision;
import gmovil_jpa.entidades.RequerimientoCompra;
import gmovil_jpa.entidades.OrdenCompra;
import gmovil_jpa.entidades.Modelo;
import gmovil_jpa.entidades.Factura;

/**
 *
 * @author castlerock
 */
public class UsuarioJpaController {

    public UsuarioJpaController() {
        emf = Persistence.createEntityManagerFactory("gmovil_jpaPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Usuario usuario) {
        if (usuario.getComisionList() == null) {
            usuario.setComisionList(new ArrayList<Comision>());
        }
        if (usuario.getComisionList1() == null) {
            usuario.setComisionList1(new ArrayList<Comision>());
        }
        if (usuario.getRemisionList() == null) {
            usuario.setRemisionList(new ArrayList<Remision>());
        }
        if (usuario.getRemisionList1() == null) {
            usuario.setRemisionList1(new ArrayList<Remision>());
        }
        if (usuario.getRequerimientoCompraList() == null) {
            usuario.setRequerimientoCompraList(new ArrayList<RequerimientoCompra>());
        }
        if (usuario.getRequerimientoCompraList1() == null) {
            usuario.setRequerimientoCompraList1(new ArrayList<RequerimientoCompra>());
        }
        if (usuario.getOrdenCompraList() == null) {
            usuario.setOrdenCompraList(new ArrayList<OrdenCompra>());
        }
        if (usuario.getOrdenCompraList1() == null) {
            usuario.setOrdenCompraList1(new ArrayList<OrdenCompra>());
        }
        if (usuario.getModeloList() == null) {
            usuario.setModeloList(new ArrayList<Modelo>());
        }
        if (usuario.getModeloList1() == null) {
            usuario.setModeloList1(new ArrayList<Modelo>());
        }
        if (usuario.getFacturaList() == null) {
            usuario.setFacturaList(new ArrayList<Factura>());
        }
        if (usuario.getFacturaList1() == null) {
            usuario.setFacturaList1(new ArrayList<Factura>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            PerfilUsuario perfilUsuario = usuario.getPerfilUsuario();
            if (perfilUsuario != null) {
                perfilUsuario = em.getReference(perfilUsuario.getClass(), perfilUsuario.getIdPerfilUsuario());
                usuario.setPerfilUsuario(perfilUsuario);
            }
            List<Comision> attachedComisionList = new ArrayList<Comision>();
            for (Comision comisionListComisionToAttach : usuario.getComisionList()) {
                comisionListComisionToAttach = em.getReference(comisionListComisionToAttach.getClass(), comisionListComisionToAttach.getIdComision());
                attachedComisionList.add(comisionListComisionToAttach);
            }
            usuario.setComisionList(attachedComisionList);
            List<Comision> attachedComisionList1 = new ArrayList<Comision>();
            for (Comision comisionList1ComisionToAttach : usuario.getComisionList1()) {
                comisionList1ComisionToAttach = em.getReference(comisionList1ComisionToAttach.getClass(), comisionList1ComisionToAttach.getIdComision());
                attachedComisionList1.add(comisionList1ComisionToAttach);
            }
            usuario.setComisionList1(attachedComisionList1);
            List<Remision> attachedRemisionList = new ArrayList<Remision>();
            for (Remision remisionListRemisionToAttach : usuario.getRemisionList()) {
                remisionListRemisionToAttach = em.getReference(remisionListRemisionToAttach.getClass(), remisionListRemisionToAttach.getIdRemision());
                attachedRemisionList.add(remisionListRemisionToAttach);
            }
            usuario.setRemisionList(attachedRemisionList);
            List<Remision> attachedRemisionList1 = new ArrayList<Remision>();
            for (Remision remisionList1RemisionToAttach : usuario.getRemisionList1()) {
                remisionList1RemisionToAttach = em.getReference(remisionList1RemisionToAttach.getClass(), remisionList1RemisionToAttach.getIdRemision());
                attachedRemisionList1.add(remisionList1RemisionToAttach);
            }
            usuario.setRemisionList1(attachedRemisionList1);
            List<RequerimientoCompra> attachedRequerimientoCompraList = new ArrayList<RequerimientoCompra>();
            for (RequerimientoCompra requerimientoCompraListRequerimientoCompraToAttach : usuario.getRequerimientoCompraList()) {
                requerimientoCompraListRequerimientoCompraToAttach = em.getReference(requerimientoCompraListRequerimientoCompraToAttach.getClass(), requerimientoCompraListRequerimientoCompraToAttach.getIdRequerimientoCompra());
                attachedRequerimientoCompraList.add(requerimientoCompraListRequerimientoCompraToAttach);
            }
            usuario.setRequerimientoCompraList(attachedRequerimientoCompraList);
            List<RequerimientoCompra> attachedRequerimientoCompraList1 = new ArrayList<RequerimientoCompra>();
            for (RequerimientoCompra requerimientoCompraList1RequerimientoCompraToAttach : usuario.getRequerimientoCompraList1()) {
                requerimientoCompraList1RequerimientoCompraToAttach = em.getReference(requerimientoCompraList1RequerimientoCompraToAttach.getClass(), requerimientoCompraList1RequerimientoCompraToAttach.getIdRequerimientoCompra());
                attachedRequerimientoCompraList1.add(requerimientoCompraList1RequerimientoCompraToAttach);
            }
            usuario.setRequerimientoCompraList1(attachedRequerimientoCompraList1);
            List<OrdenCompra> attachedOrdenCompraList = new ArrayList<OrdenCompra>();
            for (OrdenCompra ordenCompraListOrdenCompraToAttach : usuario.getOrdenCompraList()) {
                ordenCompraListOrdenCompraToAttach = em.getReference(ordenCompraListOrdenCompraToAttach.getClass(), ordenCompraListOrdenCompraToAttach.getIdOrdenCompra());
                attachedOrdenCompraList.add(ordenCompraListOrdenCompraToAttach);
            }
            usuario.setOrdenCompraList(attachedOrdenCompraList);
            List<OrdenCompra> attachedOrdenCompraList1 = new ArrayList<OrdenCompra>();
            for (OrdenCompra ordenCompraList1OrdenCompraToAttach : usuario.getOrdenCompraList1()) {
                ordenCompraList1OrdenCompraToAttach = em.getReference(ordenCompraList1OrdenCompraToAttach.getClass(), ordenCompraList1OrdenCompraToAttach.getIdOrdenCompra());
                attachedOrdenCompraList1.add(ordenCompraList1OrdenCompraToAttach);
            }
            usuario.setOrdenCompraList1(attachedOrdenCompraList1);
            List<Modelo> attachedModeloList = new ArrayList<Modelo>();
            for (Modelo modeloListModeloToAttach : usuario.getModeloList()) {
                modeloListModeloToAttach = em.getReference(modeloListModeloToAttach.getClass(), modeloListModeloToAttach.getIdModelo());
                attachedModeloList.add(modeloListModeloToAttach);
            }
            usuario.setModeloList(attachedModeloList);
            List<Modelo> attachedModeloList1 = new ArrayList<Modelo>();
            for (Modelo modeloList1ModeloToAttach : usuario.getModeloList1()) {
                modeloList1ModeloToAttach = em.getReference(modeloList1ModeloToAttach.getClass(), modeloList1ModeloToAttach.getIdModelo());
                attachedModeloList1.add(modeloList1ModeloToAttach);
            }
            usuario.setModeloList1(attachedModeloList1);
            List<Factura> attachedFacturaList = new ArrayList<Factura>();
            for (Factura facturaListFacturaToAttach : usuario.getFacturaList()) {
                facturaListFacturaToAttach = em.getReference(facturaListFacturaToAttach.getClass(), facturaListFacturaToAttach.getIdFactura());
                attachedFacturaList.add(facturaListFacturaToAttach);
            }
            usuario.setFacturaList(attachedFacturaList);
            List<Factura> attachedFacturaList1 = new ArrayList<Factura>();
            for (Factura facturaList1FacturaToAttach : usuario.getFacturaList1()) {
                facturaList1FacturaToAttach = em.getReference(facturaList1FacturaToAttach.getClass(), facturaList1FacturaToAttach.getIdFactura());
                attachedFacturaList1.add(facturaList1FacturaToAttach);
            }
            usuario.setFacturaList1(attachedFacturaList1);
            em.persist(usuario);
            if (perfilUsuario != null) {
                perfilUsuario.getUsuarioList().add(usuario);
                perfilUsuario = em.merge(perfilUsuario);
            }
            for (Comision comisionListComision : usuario.getComisionList()) {
                Usuario oldUsuarioOfComisionListComision = comisionListComision.getUsuario();
                comisionListComision.setUsuario(usuario);
                comisionListComision = em.merge(comisionListComision);
                if (oldUsuarioOfComisionListComision != null) {
                    oldUsuarioOfComisionListComision.getComisionList().remove(comisionListComision);
                    oldUsuarioOfComisionListComision = em.merge(oldUsuarioOfComisionListComision);
                }
            }
            for (Comision comisionList1Comision : usuario.getComisionList1()) {
                Usuario oldUsuario1OfComisionList1Comision = comisionList1Comision.getUsuario1();
                comisionList1Comision.setUsuario1(usuario);
                comisionList1Comision = em.merge(comisionList1Comision);
                if (oldUsuario1OfComisionList1Comision != null) {
                    oldUsuario1OfComisionList1Comision.getComisionList1().remove(comisionList1Comision);
                    oldUsuario1OfComisionList1Comision = em.merge(oldUsuario1OfComisionList1Comision);
                }
            }
            for (Remision remisionListRemision : usuario.getRemisionList()) {
                Usuario oldUsuarioOfRemisionListRemision = remisionListRemision.getUsuario();
                remisionListRemision.setUsuario(usuario);
                remisionListRemision = em.merge(remisionListRemision);
                if (oldUsuarioOfRemisionListRemision != null) {
                    oldUsuarioOfRemisionListRemision.getRemisionList().remove(remisionListRemision);
                    oldUsuarioOfRemisionListRemision = em.merge(oldUsuarioOfRemisionListRemision);
                }
            }
            for (Remision remisionList1Remision : usuario.getRemisionList1()) {
                Usuario oldUsuario1OfRemisionList1Remision = remisionList1Remision.getUsuario1();
                remisionList1Remision.setUsuario1(usuario);
                remisionList1Remision = em.merge(remisionList1Remision);
                if (oldUsuario1OfRemisionList1Remision != null) {
                    oldUsuario1OfRemisionList1Remision.getRemisionList1().remove(remisionList1Remision);
                    oldUsuario1OfRemisionList1Remision = em.merge(oldUsuario1OfRemisionList1Remision);
                }
            }
            for (RequerimientoCompra requerimientoCompraListRequerimientoCompra : usuario.getRequerimientoCompraList()) {
                Usuario oldUsuarioOfRequerimientoCompraListRequerimientoCompra = requerimientoCompraListRequerimientoCompra.getUsuario();
                requerimientoCompraListRequerimientoCompra.setUsuario(usuario);
                requerimientoCompraListRequerimientoCompra = em.merge(requerimientoCompraListRequerimientoCompra);
                if (oldUsuarioOfRequerimientoCompraListRequerimientoCompra != null) {
                    oldUsuarioOfRequerimientoCompraListRequerimientoCompra.getRequerimientoCompraList().remove(requerimientoCompraListRequerimientoCompra);
                    oldUsuarioOfRequerimientoCompraListRequerimientoCompra = em.merge(oldUsuarioOfRequerimientoCompraListRequerimientoCompra);
                }
            }
            for (RequerimientoCompra requerimientoCompraList1RequerimientoCompra : usuario.getRequerimientoCompraList1()) {
                Usuario oldUsuario1OfRequerimientoCompraList1RequerimientoCompra = requerimientoCompraList1RequerimientoCompra.getUsuario1();
                requerimientoCompraList1RequerimientoCompra.setUsuario1(usuario);
                requerimientoCompraList1RequerimientoCompra = em.merge(requerimientoCompraList1RequerimientoCompra);
                if (oldUsuario1OfRequerimientoCompraList1RequerimientoCompra != null) {
                    oldUsuario1OfRequerimientoCompraList1RequerimientoCompra.getRequerimientoCompraList1().remove(requerimientoCompraList1RequerimientoCompra);
                    oldUsuario1OfRequerimientoCompraList1RequerimientoCompra = em.merge(oldUsuario1OfRequerimientoCompraList1RequerimientoCompra);
                }
            }
            for (OrdenCompra ordenCompraListOrdenCompra : usuario.getOrdenCompraList()) {
                Usuario oldUsuarioOfOrdenCompraListOrdenCompra = ordenCompraListOrdenCompra.getUsuario();
                ordenCompraListOrdenCompra.setUsuario(usuario);
                ordenCompraListOrdenCompra = em.merge(ordenCompraListOrdenCompra);
                if (oldUsuarioOfOrdenCompraListOrdenCompra != null) {
                    oldUsuarioOfOrdenCompraListOrdenCompra.getOrdenCompraList().remove(ordenCompraListOrdenCompra);
                    oldUsuarioOfOrdenCompraListOrdenCompra = em.merge(oldUsuarioOfOrdenCompraListOrdenCompra);
                }
            }
            for (OrdenCompra ordenCompraList1OrdenCompra : usuario.getOrdenCompraList1()) {
                Usuario oldUsuario1OfOrdenCompraList1OrdenCompra = ordenCompraList1OrdenCompra.getUsuario1();
                ordenCompraList1OrdenCompra.setUsuario1(usuario);
                ordenCompraList1OrdenCompra = em.merge(ordenCompraList1OrdenCompra);
                if (oldUsuario1OfOrdenCompraList1OrdenCompra != null) {
                    oldUsuario1OfOrdenCompraList1OrdenCompra.getOrdenCompraList1().remove(ordenCompraList1OrdenCompra);
                    oldUsuario1OfOrdenCompraList1OrdenCompra = em.merge(oldUsuario1OfOrdenCompraList1OrdenCompra);
                }
            }
            for (Modelo modeloListModelo : usuario.getModeloList()) {
                Usuario oldUsuarioOfModeloListModelo = modeloListModelo.getUsuario();
                modeloListModelo.setUsuario(usuario);
                modeloListModelo = em.merge(modeloListModelo);
                if (oldUsuarioOfModeloListModelo != null) {
                    oldUsuarioOfModeloListModelo.getModeloList().remove(modeloListModelo);
                    oldUsuarioOfModeloListModelo = em.merge(oldUsuarioOfModeloListModelo);
                }
            }
            for (Modelo modeloList1Modelo : usuario.getModeloList1()) {
                Usuario oldUsuario1OfModeloList1Modelo = modeloList1Modelo.getUsuario1();
                modeloList1Modelo.setUsuario1(usuario);
                modeloList1Modelo = em.merge(modeloList1Modelo);
                if (oldUsuario1OfModeloList1Modelo != null) {
                    oldUsuario1OfModeloList1Modelo.getModeloList1().remove(modeloList1Modelo);
                    oldUsuario1OfModeloList1Modelo = em.merge(oldUsuario1OfModeloList1Modelo);
                }
            }
            for (Factura facturaListFactura : usuario.getFacturaList()) {
                Usuario oldUsuarioOfFacturaListFactura = facturaListFactura.getUsuario();
                facturaListFactura.setUsuario(usuario);
                facturaListFactura = em.merge(facturaListFactura);
                if (oldUsuarioOfFacturaListFactura != null) {
                    oldUsuarioOfFacturaListFactura.getFacturaList().remove(facturaListFactura);
                    oldUsuarioOfFacturaListFactura = em.merge(oldUsuarioOfFacturaListFactura);
                }
            }
            for (Factura facturaList1Factura : usuario.getFacturaList1()) {
                Usuario oldUsuario1OfFacturaList1Factura = facturaList1Factura.getUsuario1();
                facturaList1Factura.setUsuario1(usuario);
                facturaList1Factura = em.merge(facturaList1Factura);
                if (oldUsuario1OfFacturaList1Factura != null) {
                    oldUsuario1OfFacturaList1Factura.getFacturaList1().remove(facturaList1Factura);
                    oldUsuario1OfFacturaList1Factura = em.merge(oldUsuario1OfFacturaList1Factura);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Usuario usuario) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario persistentUsuario = em.find(Usuario.class, usuario.getIdUsuario());
            PerfilUsuario perfilUsuarioOld = persistentUsuario.getPerfilUsuario();
            PerfilUsuario perfilUsuarioNew = usuario.getPerfilUsuario();
            List<Comision> comisionListOld = persistentUsuario.getComisionList();
            List<Comision> comisionListNew = usuario.getComisionList();
            List<Comision> comisionList1Old = persistentUsuario.getComisionList1();
            List<Comision> comisionList1New = usuario.getComisionList1();
            List<Remision> remisionListOld = persistentUsuario.getRemisionList();
            List<Remision> remisionListNew = usuario.getRemisionList();
            List<Remision> remisionList1Old = persistentUsuario.getRemisionList1();
            List<Remision> remisionList1New = usuario.getRemisionList1();
            List<RequerimientoCompra> requerimientoCompraListOld = persistentUsuario.getRequerimientoCompraList();
            List<RequerimientoCompra> requerimientoCompraListNew = usuario.getRequerimientoCompraList();
            List<RequerimientoCompra> requerimientoCompraList1Old = persistentUsuario.getRequerimientoCompraList1();
            List<RequerimientoCompra> requerimientoCompraList1New = usuario.getRequerimientoCompraList1();
            List<OrdenCompra> ordenCompraListOld = persistentUsuario.getOrdenCompraList();
            List<OrdenCompra> ordenCompraListNew = usuario.getOrdenCompraList();
            List<OrdenCompra> ordenCompraList1Old = persistentUsuario.getOrdenCompraList1();
            List<OrdenCompra> ordenCompraList1New = usuario.getOrdenCompraList1();
            List<Modelo> modeloListOld = persistentUsuario.getModeloList();
            List<Modelo> modeloListNew = usuario.getModeloList();
            List<Modelo> modeloList1Old = persistentUsuario.getModeloList1();
            List<Modelo> modeloList1New = usuario.getModeloList1();
            List<Factura> facturaListOld = persistentUsuario.getFacturaList();
            List<Factura> facturaListNew = usuario.getFacturaList();
            List<Factura> facturaList1Old = persistentUsuario.getFacturaList1();
            List<Factura> facturaList1New = usuario.getFacturaList1();
            List<String> illegalOrphanMessages = null;
            for (Comision comisionList1OldComision : comisionList1Old) {
                if (!comisionList1New.contains(comisionList1OldComision)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Comision " + comisionList1OldComision + " since its usuario1 field is not nullable.");
                }
            }
            for (Remision remisionList1OldRemision : remisionList1Old) {
                if (!remisionList1New.contains(remisionList1OldRemision)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Remision " + remisionList1OldRemision + " since its usuario1 field is not nullable.");
                }
            }
            for (RequerimientoCompra requerimientoCompraList1OldRequerimientoCompra : requerimientoCompraList1Old) {
                if (!requerimientoCompraList1New.contains(requerimientoCompraList1OldRequerimientoCompra)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain RequerimientoCompra " + requerimientoCompraList1OldRequerimientoCompra + " since its usuario1 field is not nullable.");
                }
            }
            for (OrdenCompra ordenCompraList1OldOrdenCompra : ordenCompraList1Old) {
                if (!ordenCompraList1New.contains(ordenCompraList1OldOrdenCompra)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain OrdenCompra " + ordenCompraList1OldOrdenCompra + " since its usuario1 field is not nullable.");
                }
            }
            for (Modelo modeloList1OldModelo : modeloList1Old) {
                if (!modeloList1New.contains(modeloList1OldModelo)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Modelo " + modeloList1OldModelo + " since its usuario1 field is not nullable.");
                }
            }
            for (Factura facturaList1OldFactura : facturaList1Old) {
                if (!facturaList1New.contains(facturaList1OldFactura)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Factura " + facturaList1OldFactura + " since its usuario1 field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (perfilUsuarioNew != null) {
                perfilUsuarioNew = em.getReference(perfilUsuarioNew.getClass(), perfilUsuarioNew.getIdPerfilUsuario());
                usuario.setPerfilUsuario(perfilUsuarioNew);
            }
            List<Comision> attachedComisionListNew = new ArrayList<Comision>();
            for (Comision comisionListNewComisionToAttach : comisionListNew) {
                comisionListNewComisionToAttach = em.getReference(comisionListNewComisionToAttach.getClass(), comisionListNewComisionToAttach.getIdComision());
                attachedComisionListNew.add(comisionListNewComisionToAttach);
            }
            comisionListNew = attachedComisionListNew;
            usuario.setComisionList(comisionListNew);
            List<Comision> attachedComisionList1New = new ArrayList<Comision>();
            for (Comision comisionList1NewComisionToAttach : comisionList1New) {
                comisionList1NewComisionToAttach = em.getReference(comisionList1NewComisionToAttach.getClass(), comisionList1NewComisionToAttach.getIdComision());
                attachedComisionList1New.add(comisionList1NewComisionToAttach);
            }
            comisionList1New = attachedComisionList1New;
            usuario.setComisionList1(comisionList1New);
            List<Remision> attachedRemisionListNew = new ArrayList<Remision>();
            for (Remision remisionListNewRemisionToAttach : remisionListNew) {
                remisionListNewRemisionToAttach = em.getReference(remisionListNewRemisionToAttach.getClass(), remisionListNewRemisionToAttach.getIdRemision());
                attachedRemisionListNew.add(remisionListNewRemisionToAttach);
            }
            remisionListNew = attachedRemisionListNew;
            usuario.setRemisionList(remisionListNew);
            List<Remision> attachedRemisionList1New = new ArrayList<Remision>();
            for (Remision remisionList1NewRemisionToAttach : remisionList1New) {
                remisionList1NewRemisionToAttach = em.getReference(remisionList1NewRemisionToAttach.getClass(), remisionList1NewRemisionToAttach.getIdRemision());
                attachedRemisionList1New.add(remisionList1NewRemisionToAttach);
            }
            remisionList1New = attachedRemisionList1New;
            usuario.setRemisionList1(remisionList1New);
            List<RequerimientoCompra> attachedRequerimientoCompraListNew = new ArrayList<RequerimientoCompra>();
            for (RequerimientoCompra requerimientoCompraListNewRequerimientoCompraToAttach : requerimientoCompraListNew) {
                requerimientoCompraListNewRequerimientoCompraToAttach = em.getReference(requerimientoCompraListNewRequerimientoCompraToAttach.getClass(), requerimientoCompraListNewRequerimientoCompraToAttach.getIdRequerimientoCompra());
                attachedRequerimientoCompraListNew.add(requerimientoCompraListNewRequerimientoCompraToAttach);
            }
            requerimientoCompraListNew = attachedRequerimientoCompraListNew;
            usuario.setRequerimientoCompraList(requerimientoCompraListNew);
            List<RequerimientoCompra> attachedRequerimientoCompraList1New = new ArrayList<RequerimientoCompra>();
            for (RequerimientoCompra requerimientoCompraList1NewRequerimientoCompraToAttach : requerimientoCompraList1New) {
                requerimientoCompraList1NewRequerimientoCompraToAttach = em.getReference(requerimientoCompraList1NewRequerimientoCompraToAttach.getClass(), requerimientoCompraList1NewRequerimientoCompraToAttach.getIdRequerimientoCompra());
                attachedRequerimientoCompraList1New.add(requerimientoCompraList1NewRequerimientoCompraToAttach);
            }
            requerimientoCompraList1New = attachedRequerimientoCompraList1New;
            usuario.setRequerimientoCompraList1(requerimientoCompraList1New);
            List<OrdenCompra> attachedOrdenCompraListNew = new ArrayList<OrdenCompra>();
            for (OrdenCompra ordenCompraListNewOrdenCompraToAttach : ordenCompraListNew) {
                ordenCompraListNewOrdenCompraToAttach = em.getReference(ordenCompraListNewOrdenCompraToAttach.getClass(), ordenCompraListNewOrdenCompraToAttach.getIdOrdenCompra());
                attachedOrdenCompraListNew.add(ordenCompraListNewOrdenCompraToAttach);
            }
            ordenCompraListNew = attachedOrdenCompraListNew;
            usuario.setOrdenCompraList(ordenCompraListNew);
            List<OrdenCompra> attachedOrdenCompraList1New = new ArrayList<OrdenCompra>();
            for (OrdenCompra ordenCompraList1NewOrdenCompraToAttach : ordenCompraList1New) {
                ordenCompraList1NewOrdenCompraToAttach = em.getReference(ordenCompraList1NewOrdenCompraToAttach.getClass(), ordenCompraList1NewOrdenCompraToAttach.getIdOrdenCompra());
                attachedOrdenCompraList1New.add(ordenCompraList1NewOrdenCompraToAttach);
            }
            ordenCompraList1New = attachedOrdenCompraList1New;
            usuario.setOrdenCompraList1(ordenCompraList1New);
            List<Modelo> attachedModeloListNew = new ArrayList<Modelo>();
            for (Modelo modeloListNewModeloToAttach : modeloListNew) {
                modeloListNewModeloToAttach = em.getReference(modeloListNewModeloToAttach.getClass(), modeloListNewModeloToAttach.getIdModelo());
                attachedModeloListNew.add(modeloListNewModeloToAttach);
            }
            modeloListNew = attachedModeloListNew;
            usuario.setModeloList(modeloListNew);
            List<Modelo> attachedModeloList1New = new ArrayList<Modelo>();
            for (Modelo modeloList1NewModeloToAttach : modeloList1New) {
                modeloList1NewModeloToAttach = em.getReference(modeloList1NewModeloToAttach.getClass(), modeloList1NewModeloToAttach.getIdModelo());
                attachedModeloList1New.add(modeloList1NewModeloToAttach);
            }
            modeloList1New = attachedModeloList1New;
            usuario.setModeloList1(modeloList1New);
            List<Factura> attachedFacturaListNew = new ArrayList<Factura>();
            for (Factura facturaListNewFacturaToAttach : facturaListNew) {
                facturaListNewFacturaToAttach = em.getReference(facturaListNewFacturaToAttach.getClass(), facturaListNewFacturaToAttach.getIdFactura());
                attachedFacturaListNew.add(facturaListNewFacturaToAttach);
            }
            facturaListNew = attachedFacturaListNew;
            usuario.setFacturaList(facturaListNew);
            List<Factura> attachedFacturaList1New = new ArrayList<Factura>();
            for (Factura facturaList1NewFacturaToAttach : facturaList1New) {
                facturaList1NewFacturaToAttach = em.getReference(facturaList1NewFacturaToAttach.getClass(), facturaList1NewFacturaToAttach.getIdFactura());
                attachedFacturaList1New.add(facturaList1NewFacturaToAttach);
            }
            facturaList1New = attachedFacturaList1New;
            usuario.setFacturaList1(facturaList1New);
            usuario = em.merge(usuario);
            if (perfilUsuarioOld != null && !perfilUsuarioOld.equals(perfilUsuarioNew)) {
                perfilUsuarioOld.getUsuarioList().remove(usuario);
                perfilUsuarioOld = em.merge(perfilUsuarioOld);
            }
            if (perfilUsuarioNew != null && !perfilUsuarioNew.equals(perfilUsuarioOld)) {
                perfilUsuarioNew.getUsuarioList().add(usuario);
                perfilUsuarioNew = em.merge(perfilUsuarioNew);
            }
            for (Comision comisionListOldComision : comisionListOld) {
                if (!comisionListNew.contains(comisionListOldComision)) {
                    comisionListOldComision.setUsuario(null);
                    comisionListOldComision = em.merge(comisionListOldComision);
                }
            }
            for (Comision comisionListNewComision : comisionListNew) {
                if (!comisionListOld.contains(comisionListNewComision)) {
                    Usuario oldUsuarioOfComisionListNewComision = comisionListNewComision.getUsuario();
                    comisionListNewComision.setUsuario(usuario);
                    comisionListNewComision = em.merge(comisionListNewComision);
                    if (oldUsuarioOfComisionListNewComision != null && !oldUsuarioOfComisionListNewComision.equals(usuario)) {
                        oldUsuarioOfComisionListNewComision.getComisionList().remove(comisionListNewComision);
                        oldUsuarioOfComisionListNewComision = em.merge(oldUsuarioOfComisionListNewComision);
                    }
                }
            }
            for (Comision comisionList1NewComision : comisionList1New) {
                if (!comisionList1Old.contains(comisionList1NewComision)) {
                    Usuario oldUsuario1OfComisionList1NewComision = comisionList1NewComision.getUsuario1();
                    comisionList1NewComision.setUsuario1(usuario);
                    comisionList1NewComision = em.merge(comisionList1NewComision);
                    if (oldUsuario1OfComisionList1NewComision != null && !oldUsuario1OfComisionList1NewComision.equals(usuario)) {
                        oldUsuario1OfComisionList1NewComision.getComisionList1().remove(comisionList1NewComision);
                        oldUsuario1OfComisionList1NewComision = em.merge(oldUsuario1OfComisionList1NewComision);
                    }
                }
            }
            for (Remision remisionListOldRemision : remisionListOld) {
                if (!remisionListNew.contains(remisionListOldRemision)) {
                    remisionListOldRemision.setUsuario(null);
                    remisionListOldRemision = em.merge(remisionListOldRemision);
                }
            }
            for (Remision remisionListNewRemision : remisionListNew) {
                if (!remisionListOld.contains(remisionListNewRemision)) {
                    Usuario oldUsuarioOfRemisionListNewRemision = remisionListNewRemision.getUsuario();
                    remisionListNewRemision.setUsuario(usuario);
                    remisionListNewRemision = em.merge(remisionListNewRemision);
                    if (oldUsuarioOfRemisionListNewRemision != null && !oldUsuarioOfRemisionListNewRemision.equals(usuario)) {
                        oldUsuarioOfRemisionListNewRemision.getRemisionList().remove(remisionListNewRemision);
                        oldUsuarioOfRemisionListNewRemision = em.merge(oldUsuarioOfRemisionListNewRemision);
                    }
                }
            }
            for (Remision remisionList1NewRemision : remisionList1New) {
                if (!remisionList1Old.contains(remisionList1NewRemision)) {
                    Usuario oldUsuario1OfRemisionList1NewRemision = remisionList1NewRemision.getUsuario1();
                    remisionList1NewRemision.setUsuario1(usuario);
                    remisionList1NewRemision = em.merge(remisionList1NewRemision);
                    if (oldUsuario1OfRemisionList1NewRemision != null && !oldUsuario1OfRemisionList1NewRemision.equals(usuario)) {
                        oldUsuario1OfRemisionList1NewRemision.getRemisionList1().remove(remisionList1NewRemision);
                        oldUsuario1OfRemisionList1NewRemision = em.merge(oldUsuario1OfRemisionList1NewRemision);
                    }
                }
            }
            for (RequerimientoCompra requerimientoCompraListOldRequerimientoCompra : requerimientoCompraListOld) {
                if (!requerimientoCompraListNew.contains(requerimientoCompraListOldRequerimientoCompra)) {
                    requerimientoCompraListOldRequerimientoCompra.setUsuario(null);
                    requerimientoCompraListOldRequerimientoCompra = em.merge(requerimientoCompraListOldRequerimientoCompra);
                }
            }
            for (RequerimientoCompra requerimientoCompraListNewRequerimientoCompra : requerimientoCompraListNew) {
                if (!requerimientoCompraListOld.contains(requerimientoCompraListNewRequerimientoCompra)) {
                    Usuario oldUsuarioOfRequerimientoCompraListNewRequerimientoCompra = requerimientoCompraListNewRequerimientoCompra.getUsuario();
                    requerimientoCompraListNewRequerimientoCompra.setUsuario(usuario);
                    requerimientoCompraListNewRequerimientoCompra = em.merge(requerimientoCompraListNewRequerimientoCompra);
                    if (oldUsuarioOfRequerimientoCompraListNewRequerimientoCompra != null && !oldUsuarioOfRequerimientoCompraListNewRequerimientoCompra.equals(usuario)) {
                        oldUsuarioOfRequerimientoCompraListNewRequerimientoCompra.getRequerimientoCompraList().remove(requerimientoCompraListNewRequerimientoCompra);
                        oldUsuarioOfRequerimientoCompraListNewRequerimientoCompra = em.merge(oldUsuarioOfRequerimientoCompraListNewRequerimientoCompra);
                    }
                }
            }
            for (RequerimientoCompra requerimientoCompraList1NewRequerimientoCompra : requerimientoCompraList1New) {
                if (!requerimientoCompraList1Old.contains(requerimientoCompraList1NewRequerimientoCompra)) {
                    Usuario oldUsuario1OfRequerimientoCompraList1NewRequerimientoCompra = requerimientoCompraList1NewRequerimientoCompra.getUsuario1();
                    requerimientoCompraList1NewRequerimientoCompra.setUsuario1(usuario);
                    requerimientoCompraList1NewRequerimientoCompra = em.merge(requerimientoCompraList1NewRequerimientoCompra);
                    if (oldUsuario1OfRequerimientoCompraList1NewRequerimientoCompra != null && !oldUsuario1OfRequerimientoCompraList1NewRequerimientoCompra.equals(usuario)) {
                        oldUsuario1OfRequerimientoCompraList1NewRequerimientoCompra.getRequerimientoCompraList1().remove(requerimientoCompraList1NewRequerimientoCompra);
                        oldUsuario1OfRequerimientoCompraList1NewRequerimientoCompra = em.merge(oldUsuario1OfRequerimientoCompraList1NewRequerimientoCompra);
                    }
                }
            }
            for (OrdenCompra ordenCompraListOldOrdenCompra : ordenCompraListOld) {
                if (!ordenCompraListNew.contains(ordenCompraListOldOrdenCompra)) {
                    ordenCompraListOldOrdenCompra.setUsuario(null);
                    ordenCompraListOldOrdenCompra = em.merge(ordenCompraListOldOrdenCompra);
                }
            }
            for (OrdenCompra ordenCompraListNewOrdenCompra : ordenCompraListNew) {
                if (!ordenCompraListOld.contains(ordenCompraListNewOrdenCompra)) {
                    Usuario oldUsuarioOfOrdenCompraListNewOrdenCompra = ordenCompraListNewOrdenCompra.getUsuario();
                    ordenCompraListNewOrdenCompra.setUsuario(usuario);
                    ordenCompraListNewOrdenCompra = em.merge(ordenCompraListNewOrdenCompra);
                    if (oldUsuarioOfOrdenCompraListNewOrdenCompra != null && !oldUsuarioOfOrdenCompraListNewOrdenCompra.equals(usuario)) {
                        oldUsuarioOfOrdenCompraListNewOrdenCompra.getOrdenCompraList().remove(ordenCompraListNewOrdenCompra);
                        oldUsuarioOfOrdenCompraListNewOrdenCompra = em.merge(oldUsuarioOfOrdenCompraListNewOrdenCompra);
                    }
                }
            }
            for (OrdenCompra ordenCompraList1NewOrdenCompra : ordenCompraList1New) {
                if (!ordenCompraList1Old.contains(ordenCompraList1NewOrdenCompra)) {
                    Usuario oldUsuario1OfOrdenCompraList1NewOrdenCompra = ordenCompraList1NewOrdenCompra.getUsuario1();
                    ordenCompraList1NewOrdenCompra.setUsuario1(usuario);
                    ordenCompraList1NewOrdenCompra = em.merge(ordenCompraList1NewOrdenCompra);
                    if (oldUsuario1OfOrdenCompraList1NewOrdenCompra != null && !oldUsuario1OfOrdenCompraList1NewOrdenCompra.equals(usuario)) {
                        oldUsuario1OfOrdenCompraList1NewOrdenCompra.getOrdenCompraList1().remove(ordenCompraList1NewOrdenCompra);
                        oldUsuario1OfOrdenCompraList1NewOrdenCompra = em.merge(oldUsuario1OfOrdenCompraList1NewOrdenCompra);
                    }
                }
            }
            for (Modelo modeloListOldModelo : modeloListOld) {
                if (!modeloListNew.contains(modeloListOldModelo)) {
                    modeloListOldModelo.setUsuario(null);
                    modeloListOldModelo = em.merge(modeloListOldModelo);
                }
            }
            for (Modelo modeloListNewModelo : modeloListNew) {
                if (!modeloListOld.contains(modeloListNewModelo)) {
                    Usuario oldUsuarioOfModeloListNewModelo = modeloListNewModelo.getUsuario();
                    modeloListNewModelo.setUsuario(usuario);
                    modeloListNewModelo = em.merge(modeloListNewModelo);
                    if (oldUsuarioOfModeloListNewModelo != null && !oldUsuarioOfModeloListNewModelo.equals(usuario)) {
                        oldUsuarioOfModeloListNewModelo.getModeloList().remove(modeloListNewModelo);
                        oldUsuarioOfModeloListNewModelo = em.merge(oldUsuarioOfModeloListNewModelo);
                    }
                }
            }
            for (Modelo modeloList1NewModelo : modeloList1New) {
                if (!modeloList1Old.contains(modeloList1NewModelo)) {
                    Usuario oldUsuario1OfModeloList1NewModelo = modeloList1NewModelo.getUsuario1();
                    modeloList1NewModelo.setUsuario1(usuario);
                    modeloList1NewModelo = em.merge(modeloList1NewModelo);
                    if (oldUsuario1OfModeloList1NewModelo != null && !oldUsuario1OfModeloList1NewModelo.equals(usuario)) {
                        oldUsuario1OfModeloList1NewModelo.getModeloList1().remove(modeloList1NewModelo);
                        oldUsuario1OfModeloList1NewModelo = em.merge(oldUsuario1OfModeloList1NewModelo);
                    }
                }
            }
            for (Factura facturaListOldFactura : facturaListOld) {
                if (!facturaListNew.contains(facturaListOldFactura)) {
                    facturaListOldFactura.setUsuario(null);
                    facturaListOldFactura = em.merge(facturaListOldFactura);
                }
            }
            for (Factura facturaListNewFactura : facturaListNew) {
                if (!facturaListOld.contains(facturaListNewFactura)) {
                    Usuario oldUsuarioOfFacturaListNewFactura = facturaListNewFactura.getUsuario();
                    facturaListNewFactura.setUsuario(usuario);
                    facturaListNewFactura = em.merge(facturaListNewFactura);
                    if (oldUsuarioOfFacturaListNewFactura != null && !oldUsuarioOfFacturaListNewFactura.equals(usuario)) {
                        oldUsuarioOfFacturaListNewFactura.getFacturaList().remove(facturaListNewFactura);
                        oldUsuarioOfFacturaListNewFactura = em.merge(oldUsuarioOfFacturaListNewFactura);
                    }
                }
            }
            for (Factura facturaList1NewFactura : facturaList1New) {
                if (!facturaList1Old.contains(facturaList1NewFactura)) {
                    Usuario oldUsuario1OfFacturaList1NewFactura = facturaList1NewFactura.getUsuario1();
                    facturaList1NewFactura.setUsuario1(usuario);
                    facturaList1NewFactura = em.merge(facturaList1NewFactura);
                    if (oldUsuario1OfFacturaList1NewFactura != null && !oldUsuario1OfFacturaList1NewFactura.equals(usuario)) {
                        oldUsuario1OfFacturaList1NewFactura.getFacturaList1().remove(facturaList1NewFactura);
                        oldUsuario1OfFacturaList1NewFactura = em.merge(oldUsuario1OfFacturaList1NewFactura);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = usuario.getIdUsuario();
                if (findUsuario(id) == null) {
                    throw new NonexistentEntityException("The usuario with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario usuario;
            try {
                usuario = em.getReference(Usuario.class, id);
                usuario.getIdUsuario();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The usuario with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Comision> comisionList1OrphanCheck = usuario.getComisionList1();
            for (Comision comisionList1OrphanCheckComision : comisionList1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Comision " + comisionList1OrphanCheckComision + " in its comisionList1 field has a non-nullable usuario1 field.");
            }
            List<Remision> remisionList1OrphanCheck = usuario.getRemisionList1();
            for (Remision remisionList1OrphanCheckRemision : remisionList1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Remision " + remisionList1OrphanCheckRemision + " in its remisionList1 field has a non-nullable usuario1 field.");
            }
            List<RequerimientoCompra> requerimientoCompraList1OrphanCheck = usuario.getRequerimientoCompraList1();
            for (RequerimientoCompra requerimientoCompraList1OrphanCheckRequerimientoCompra : requerimientoCompraList1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the RequerimientoCompra " + requerimientoCompraList1OrphanCheckRequerimientoCompra + " in its requerimientoCompraList1 field has a non-nullable usuario1 field.");
            }
            List<OrdenCompra> ordenCompraList1OrphanCheck = usuario.getOrdenCompraList1();
            for (OrdenCompra ordenCompraList1OrphanCheckOrdenCompra : ordenCompraList1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the OrdenCompra " + ordenCompraList1OrphanCheckOrdenCompra + " in its ordenCompraList1 field has a non-nullable usuario1 field.");
            }
            List<Modelo> modeloList1OrphanCheck = usuario.getModeloList1();
            for (Modelo modeloList1OrphanCheckModelo : modeloList1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Modelo " + modeloList1OrphanCheckModelo + " in its modeloList1 field has a non-nullable usuario1 field.");
            }
            List<Factura> facturaList1OrphanCheck = usuario.getFacturaList1();
            for (Factura facturaList1OrphanCheckFactura : facturaList1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Factura " + facturaList1OrphanCheckFactura + " in its facturaList1 field has a non-nullable usuario1 field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            PerfilUsuario perfilUsuario = usuario.getPerfilUsuario();
            if (perfilUsuario != null) {
                perfilUsuario.getUsuarioList().remove(usuario);
                perfilUsuario = em.merge(perfilUsuario);
            }
            List<Comision> comisionList = usuario.getComisionList();
            for (Comision comisionListComision : comisionList) {
                comisionListComision.setUsuario(null);
                comisionListComision = em.merge(comisionListComision);
            }
            List<Remision> remisionList = usuario.getRemisionList();
            for (Remision remisionListRemision : remisionList) {
                remisionListRemision.setUsuario(null);
                remisionListRemision = em.merge(remisionListRemision);
            }
            List<RequerimientoCompra> requerimientoCompraList = usuario.getRequerimientoCompraList();
            for (RequerimientoCompra requerimientoCompraListRequerimientoCompra : requerimientoCompraList) {
                requerimientoCompraListRequerimientoCompra.setUsuario(null);
                requerimientoCompraListRequerimientoCompra = em.merge(requerimientoCompraListRequerimientoCompra);
            }
            List<OrdenCompra> ordenCompraList = usuario.getOrdenCompraList();
            for (OrdenCompra ordenCompraListOrdenCompra : ordenCompraList) {
                ordenCompraListOrdenCompra.setUsuario(null);
                ordenCompraListOrdenCompra = em.merge(ordenCompraListOrdenCompra);
            }
            List<Modelo> modeloList = usuario.getModeloList();
            for (Modelo modeloListModelo : modeloList) {
                modeloListModelo.setUsuario(null);
                modeloListModelo = em.merge(modeloListModelo);
            }
            List<Factura> facturaList = usuario.getFacturaList();
            for (Factura facturaListFactura : facturaList) {
                facturaListFactura.setUsuario(null);
                facturaListFactura = em.merge(facturaListFactura);
            }
            em.remove(usuario);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Usuario> findUsuarioEntities() {
        return findUsuarioEntities(true, -1, -1);
    }

    public List<Usuario> findUsuarioEntities(int maxResults, int firstResult) {
        return findUsuarioEntities(false, maxResults, firstResult);
    }

    private List<Usuario> findUsuarioEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Usuario.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Usuario findUsuario(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Usuario.class, id);
        } finally {
            em.close();
        }
    }

    public int getUsuarioCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Usuario> rt = cq.from(Usuario.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
